import FormReg from './regexp';
let checkPass = '';
let handleValidateResult = (value, callback) => {
	if (value.length === 0){
		callback();
		return true;
	} else {
		callback(new Error(value));
		return false;
	}
}
// 密码校验
export const getValidatePassWordResult = value => {
	value += '';
	if (value.trim() === '') {
		return '格式错误，密码不能为空!';
	} else if (value.trim().length > 16 || value.trim().length < 8) {
		return '格式错误， 密码长度为 8 - 16 位!';
	} else if(!FormReg.reg15.test(value)){
        return `密码长度为8-16个字符，必须包含字母、数字、符号中至少2种，且不能与账号相同`;
	} else if(!FormReg.reg16.test(value)){
        return `密码长度为8-16个字符，必须包含字母、数字、符号中至少2种，且不能与账号相同`;
	}else {
		return '';
	}
}
export const validatePass = (rule, value, callback) => {
	if (handleValidateResult(getValidatePassWordResult(value), callback)) {
		checkPass = value;
	}
};

// 密码确认校验
export const validatePassChecked = (rule, value, callback) => {
	if (value !== checkPass) {
		callback(new Error('两次输入密码不一致!'));
	} else if (!FormReg.reg15.test(value)) {
		callback(new Error(`密码长度为8-16个字符，必须包含字母、数字、符号中至少2种，且不能与账号相同`));
	} else if(!FormReg.reg16.test(value)){
        callback(new Error(`密码长度为8-16个字符，必须包含字母、数字、符号中至少2种，且不能与账号相同`));
	} else if (value.trim() === '') {
		callback(new Error('格式错误，密码不能为空!'));
	} else if (value.trim().length > 16 || value.trim().length < 8) {
		callback(new Error('格式错误， 密码长度为 8 - 16 位!'));
	} else {
		callback();
	}
};

// 用户名校验
export const getValidateUserNameResult = value => {
	value += '';
	if (value.replace(FormReg.reg3, '').length !== 0) {
		return '格式错误，用户名只能是英文、数字以及 - @ ~ _ 等特殊字符!';
	} else if (value.trim() === '') {
		return '格式错误，用户名不能为空!';
	} else if (value.trim().length > 16 || value.trim().length < 3) {
		return '格式错误， 用户名长度为 3 - 16 位!';
	} else {
		return '';
	}
};
export const validateUserName = (rule, value, callback) => {
	handleValidateResult(getValidateUserNameResult(value), callback);
};

// 真实姓名校验
export const getValidateRealNameResult = (value, minLenght, maxLength) => {
	value += '';
	if (value.replace(FormReg.reg9, '').length !== 0) {
		return '格式错误，真实姓名只能为汉字、英语';
	} else if (value.trim() === '') {
		return '格式错误，真实姓名不能为空!';
	} else if (value.trim().length > maxLength || value.trim().length < minLenght) {
		return `格式错误，真实姓名长度必须大于 ${minLenght}, 小于 ${maxLength}`;
	} else {
		return '';
	}
};
export const getDefaultValidateRealNameResult = value => {
	return getValidateRealNameResult(value, 2, 8);
};
export const validateRealName = (rule, value, callback) => {
	handleValidateResult(getDefaultValidateRealNameResult(value), callback);
};

// 用户等级校验
export const validateLevel = (rule, value, callback) => {
	if (value.toString().replace(FormReg.reg4, '').length !== 0) {
		callback(new Error('格式错误，用户等级只能为数字！'));
	} else if (Number(value) < 0) {
		callback(new Error('格式错误，用户等级必须大于 0 !'));
	} else {
		callback();
	}
};

// 分组名校验
export const getValidateGroupNameResult = value => {
	value += '';
	if (value.replace(FormReg.reg9, '').length !== 0) {
		return '格式错误，分组名只能为汉字、英文';
	} else if (value.trim() === '') {
		return '分组名不能为空!';
	} else if (value.trim().length > 16 || value.trim().length < 2) {
		return '格式错误，分组名长度必须大于 2 小于 16';
	} else {
		return '';
	}
};
export const validateGroupName = (rule, value, callback) => {
	handleValidateResult(getValidateGroupNameResult(value), callback);
};

// 业务场景名称校验
export const validateSceneName = (rule, value, callback) => {
	let flag = new RegExp('^[A-Za-z0-9\u4e00-\u9fa5\\-_]+$', 'g').test(value);
	if (!flag) {
		callback(new Error('格式错误，业务场景名称只能为汉字、英文、数字、特殊符号 "_" 或 "-" 的组合'));
	} else if (value.trim() === '') {
		callback(new Error('业务场景名称不能为空!'));
	} else if (value.trim().length > 20 || value.trim().length < 1) {
		callback(new Error('格式错误，业务场景名称长度必须大于 1 小于 20'));
	} else {
		callback();
	}
};
// 校验工作流名称
export const validateWorkFlowName = (rule, value, callback) => {
	let flag = new RegExp('^[A-Za-z0-9\u4e00-\u9fa5]+$', 'g').test(value);
	if (!flag) {
		callback(new Error('格式错误，工作流名称只能为汉字、英文、数字'));
	} else if (value.trim() === '') {
		callback(new Error('工作流名称不能为空!'));
	} else if (value.trim().length > 40 || value.trim().length < 1) {
		callback(new Error('格式错误，工作流名称长度必须大于 1 小于 40'));
	} else {
		callback();
	}
};

// 校验工作流流程
export const validateFlowConent = (rule, value, callback) => {
	let flag = new RegExp('^[A-Za-z0-9\u4e00-\u9fa5{{}}]+$', 'g').test(value);
	if (!flag) {
		callback(new Error('格式错误，流程节点只能为汉字、英文、数字'));
	} else if (value.trim() === '') {
		callback(new Error('流程节点不能为空!'));
	} else if (value.trim().length > 40 || value.trim().length < 1) {
		callback(new Error('格式错误，流程节点长度必须大于 1 小于 40'));
	} else {
		callback();
	}
};

// 校验变量
export const validateWorkFlowVariable = (rule, value, callback) => {
	let flag = new RegExp('^[A-Za-z0-9\u4e00-\u9fa5]+$', 'g').test(value);
	if (!flag) {
		callback(new Error('格式错误，变量描述只能为汉字、英文、数字'));
	} else if (value.trim() === '') {
		callback(new Error('变量描述不能为空!'));
	} else if (value.trim().length > 40 || value.trim().length < 1) {
		callback(new Error('格式错误，变量描述长度必须大于 1 小于 40'));
	} else {
		callback();
	}
};

// 校验变量值
export const validateVariableKey = (rule, value, callback) => {
	let flag = new RegExp('^[A-Za-z]+$', 'g').test(value);
	if (!flag) {
		callback(new Error('格式错误，变量名只能为大小写英文字符'));
	} else if (value.trim() === '') {
		callback(new Error('变量名不能为空!'));
	} else if (value.trim().length > 20 || value.trim().length < 1) {
		callback(new Error('格式错误，变量名长度必须大于 1 小于 0'));
	} else {
		callback();
	}
};

// 校验AI回复话术
export const validateAiTalk = (rule, value, callback) => {
	if (value !== '') {
		// fixed bug : http://192.168.31.91:7080/browse/IVCS-696
		// console.log(value);
		// let flag = new RegExp("^[A-Za-z0-9{}_\u4e00-\u9fa5]+$", 'g').test(value)
		let flag = new RegExp('^[A-Za-z0-9!?:"{},.;\'！{}？：“”、；‘’，。、\u4e00-\u9fa5_]+$', 'g').test(value);
		if (!flag) {
			callback(new Error('仅支持输入长度100以内的中文字符，不支持特殊符号输入'));
		} else if (value.length > 100) {
			callback(new Error('仅支持输入长度100以内的中文字符，不支持特殊符号输入'));
		} else {
			callback();
		}
	} else {
		callback();
	}
};

// 校验表单名称
export const validateFormName = (rule, value, callback) => {
	let flag = new RegExp('^[A-Za-z0-9\u4e00-\u9fa5]+$', 'g').test(value);
	if (!flag) {
		callback(new Error('* 仅支持输入中英文、数字、字符长度限制20个汉字'));
	} else if (value.length > 20) {
		callback(new Error('* 仅支持输入中英文、数字、字符长度限制20个汉字'));
	} else {
		callback();
	}
};

// 角色名校验
export const getValidateRoleNameResult = value => {
	value += '';
	if (value.trim() === '') {
		return '角色名不能为空!';
	} else if (value.trim().length > 16 || value.trim().length < 1) {
		return '格式错误，角色名长度必须大于 2 小于 16';
	} else {
		return '';
	}
};
export const validateRoleName = (rule, value, callback) => {
	handleValidateResult(getValidateRoleNameResult(value), callback);
};
